package com.xpengplayer.update;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import java.io.File;

/**
 * 更新检查器
 * 提供简单的接口来检查应用更新
 */
public class UpdateChecker {
    private static final String TAG = "UpdateChecker";
    private static UpdateChecker instance;
    private Context context;
    private UpdateManager updateManager;
    private CheckUpdateTask checkUpdateTask;
    private boolean isChecking = false;
    
    public interface UpdateCallback {
        void onUpdateAvailable(UpdateInfo updateInfo);
        void onNoUpdateAvailable();
        void onError(String errorMessage);
    }
    
    private UpdateChecker(Context context) {
        this.context = context.getApplicationContext();
        this.updateManager = UpdateManager.getInstance(context);
    }
    
    /**
     * 获取UpdateChecker单例
     */
    public static synchronized UpdateChecker getInstance(Context context) {
        if (instance == null) {
            instance = new UpdateChecker(context);
        }
        return instance;
    }
    
    /**
     * 检查应用是否有更新
     */
    public void checkForUpdates(final UpdateCallback callback) {
        if (isChecking) {
            Log.d(TAG, "正在检查更新，请稍后再试");
            return;
        }
        
        isChecking = true;
        
        checkUpdateTask = new CheckUpdateTask(callback);
        checkUpdateTask.execute();
    }
    
    /**
     * 检查应用是否有更新（无参数版本，用于兼容旧代码）
     */
    public void checkForUpdates() {
        checkForUpdates(new UpdateCallback() {
            @Override
            public void onUpdateAvailable(UpdateInfo updateInfo) {
                // 默认实现，不做任何操作
                Log.d(TAG, "发现新版本: " + updateInfo.getVersionName());
            }
            
            @Override
            public void onNoUpdateAvailable() {
                // 默认实现，不做任何操作
                Log.d(TAG, "当前已是最新版本");
            }
            
            @Override
            public void onError(String errorMessage) {
                // 默认实现，只记录错误
                Log.e(TAG, "检查更新失败: " + errorMessage);
            }
        });
    }
    
    /**
     * 取消检查更新
     */
    public void cancelCheck() {
        if (checkUpdateTask != null && !checkUpdateTask.isCancelled()) {
            checkUpdateTask.cancel(true);
            checkUpdateTask = null;
        }
        isChecking = false;
    }
    
    /**
     * 是否正在检查更新
     */
    public boolean isChecking() {
        return isChecking;
    }
    
    /**
     * 检查更新的异步任务
     */
    private class CheckUpdateTask extends AsyncTask<Void, Void, Void> {
        private UpdateCallback callback;
        
        public CheckUpdateTask(UpdateCallback callback) {
            this.callback = callback;
        }
        
        @Override
        protected Void doInBackground(Void... voids) {
            try {
                // 设置UpdateManager的回调，将其转发到UpdateChecker的回调
                updateManager.setUpdateCallback(new UpdateManager.UpdateCallback() {
                    @Override
                    public void onUpdateAvailable(final UpdateInfo updateInfo) {
                        Handler handler = new Handler(Looper.getMainLooper());
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (callback != null) {
                                    callback.onUpdateAvailable(updateInfo);
                                }
                            }
                        });
                    }
                    
                    @Override
                    public void onNoUpdate() {
                        // 处理无更新的情况
                        Handler handler = new Handler(Looper.getMainLooper());
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (callback != null) {
                                    callback.onNoUpdateAvailable();
                                }
                            }
                        });
                    }
                    
                    @Override
                    public void onError(final String errorMessage) {
                        Handler handler = new Handler(Looper.getMainLooper());
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (callback != null) {
                                    callback.onError(errorMessage);
                                }
                            }
                        });
                    }
                    
                    @Override
                    public void onDownloadProgress(int progress, long downloadedSize, long totalSize) {
                        // UpdateChecker不处理下载进度
                    }
                    
                    @Override
                    public void onDownloadComplete(File apkFile) {
                        // UpdateChecker不处理下载完成
                    }
                    
                    @Override
                    public void onDownloadFailed(String errorMessage) {
                        // UpdateChecker不处理下载失败
                    }
                });
                
                // 调用UpdateManager的检查更新方法
                updateManager.checkForUpdates();
            } catch (Exception e) {
                final String errorMessage = e.getMessage();
                Log.e(TAG, "检查更新失败", e);
                Handler handler = new Handler(Looper.getMainLooper());
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (callback != null) {
                            callback.onError(errorMessage);
                        }
                    }
                });
            }
            return null;
        }
        
        @Override
        protected void onPostExecute(Void result) {
            isChecking = false;
            checkUpdateTask = null;
            
            if (isCancelled()) {
                return;
            }
            // 注意：由于UpdateManager使用异步回调，这里不做额外处理
            // 实际的更新检查结果将通过上面设置的回调返回
        }
        
        @Override
        protected void onCancelled() {
            isChecking = false;
            checkUpdateTask = null;
        }
    }
}